home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / libs / knowhow4 / drawappl.cpp < prev    next >
C/C++ Source or Header  |  1994-10-10  |  20KB  |  732 lines
  1. #include "kh_draw.h"
  2. #include <stdio.h>
  3. #include <conio.h>
  4. #include <string.h>
  5. #include "global.h"
  6. #include <dos.h>
  7. #include "ask_hot.h"             // not library - application only file.
  8.                  // Button which may be hidden and macros append
  9.                  // function
  10.  
  11.  
  12. enum { SAVE = 1, DONT_SAVE };  // picture status
  13.  
  14. enum { FILE_NEW = 30, FILE_OPEN, FILE_SAVE, FILE_SAVE_AS_BW, FILE_PRINT,
  15.        FILE_COPY_FROM, FILE_COPY_TO, FILE_COPY_TO_BW, FILE_FONT,
  16.        SCRIPT_PLAY, SCRIPT_RECORD, SCRIPT_END, MACROS_KEEP, TEXT_EDIT };
  17.  
  18. //void get_dir();    // gets list of files
  19. ////////////////////
  20. void file_refresh()     // used to get previous script name from stack
  21.     {
  22.     scriptMode = GO;
  23.     delete scriptFileName;
  24.     scriptFileName = NULL;
  25.     mac_status mac = macros_pop();         // obtain previous status
  26.     delete mac.file;
  27.     }
  28. //////////////////
  29. void KH_Draw::prepare_files()
  30.     {
  31.     delete global[1]; delete global[2];
  32.     global[1] = strdup("work"); global[2] = strdup("");
  33.     (file_sys->file_system)->setItems();
  34.     }
  35. //////////////////
  36. void KH_Draw::askSave()
  37.     {
  38.     if(!(draw->draw)->saved && ask_save())    // YES
  39.     (draw->draw)->save();
  40.     draw->draw->saved = 1;
  41.     }
  42. //////////////////////
  43. void about()
  44.     {
  45.     Board* board = new Board(rect(5, 5, 65, 20), "about.pcz",
  46.               "about.pcy", "A B O U T", 8, 0, 16);
  47.     board->show_window();
  48.  
  49.     Icon i(loc(1, 1), 2, LARGE_ICON, SHOW_BORDER);
  50.     char* file = i.icon_open();
  51.  
  52.     FILE *stream;
  53.     if((stream = fopen(file, "r+b")) == NULL)
  54.     return;
  55.     loc size = icon_size(LARGE_ICON);
  56.     int i_size = ((size.X + 1 + 7) >> 3 << 2) * (size.Y + 1) + sizeof(imageP);
  57.     imageP image = (imageP)malloc(i_size + 10);
  58.     while(1)
  59.         {
  60.         for(int j = 1; j < 9; j++)
  61.             {
  62.             get_image(stream, j, image, i_size);
  63.             putimage(screenXL(8), screenYT(8), image, COPY_PUT);
  64.             delay(20);
  65.             if(eventavail(KEYEVENT | MOUSEEVENT,
  66.                MCleftDn | MCrightDn))
  67.                 break;
  68.             }
  69.         if(eventavail(KEYEVENT | MOUSEEVENT,
  70.                MCleftDn | MCrightDn))
  71.                 break;
  72.         }
  73.     get_event();
  74.     fclose(stream);
  75.     delete image;
  76.     board->hide();
  77.     delete board;
  78.     }
  79. //////////////////////
  80. int KH_Draw::application(int n)
  81.     {
  82.     rect r = (draw->draw)->user_screen();
  83.     loc mspos = e.where();
  84.     loc minsize = loc(20, 20);
  85.     rect work;
  86.  
  87.     char** editList = edit_menu->menu->getItemStrings(); // We use pointer to
  88.                                                    // modify menu items.
  89.     sound(100); delay(100); nosound();
  90.  
  91.     if(n >= AC_LINE_1 && n <= AC_LINE_6)
  92.     {
  93.     DATA_LINE = n - AC_LINE_1 + 1;
  94.     return 1;
  95.     }
  96.  
  97.     if(n >= AC_BLACK && n <= AC_WHITE)    // set color
  98.     {
  99.     setcolor(DATA_ATTR = n - AC_BLACK);
  100.         global_i[6] = DATA_ATTR;
  101.         global_i[7] = DATA_BAK;
  102.     return 0;
  103.     }
  104.     if(n >= AC_BLACK1 && n <= AC_WHITE1)     // set background color
  105.     {
  106.         global_i[6] = DATA_ATTR;
  107.         global_i[7] = DATA_BAK;
  108.     setfillstyle(SOLID_FILL, DATA_BAK = n - AC_BLACK1);
  109.     return 0;
  110.     }
  111.     if(n >= AC_FILL1 && n <= AC_FILL48)    // set fill pattern
  112.     {
  113.     DATA_FILL = n - AC_FILL1;
  114.     return 1;
  115.     }
  116.     if(n >= AC_SIZE1 && n <= AC_SIZE2)    // it is font size
  117.     {
  118.     DATA_SIZE = (n - AC_SIZE1 + 1);
  119.     return 1;
  120.     }
  121.  
  122.     if(n >= AC_BUFFER_SIZE && n <= AC_BUFFER_SIZE7)
  123.     {
  124.     WindowManager::hide_window();    // "buffer_size"
  125.     WindowManager::hide_window();    // "file_menu"
  126.     askSave();
  127.     DATA_BUFFER_SIZE = n - AC_BUFFER_SIZE + 1;
  128.  
  129.     switch(DATA_BUFFER_SIZE)
  130.         {
  131.         case 1:
  132.         buffer->buf_dim.X = getmaxx() + 2;
  133.         buffer->buf_dim.Y = getmaxy() + 2;
  134.         break;
  135.         case 2:
  136.         buffer->buf_dim.X = 750;
  137.         buffer->buf_dim.Y = 550;
  138.         break;
  139.         case 3:
  140.         buffer->buf_dim.X = 1900;
  141.         buffer->buf_dim.Y = 2000;
  142.         break;
  143.         case 4:
  144.         buffer->buf_dim.X = 4001;
  145.         buffer->buf_dim.Y = 4000;
  146.         break;
  147.         case 5:
  148.         buffer->buf_dim.X = 8001;
  149.         buffer->buf_dim.Y = 8000;
  150.         break;
  151.         case 6:
  152.         buffer->buf_dim.X = 10001;
  153.         buffer->buf_dim.Y = 16000;
  154.         break;
  155.         case 7:
  156.         buffer->buf_dim.X = 12001;
  157.         buffer->buf_dim.Y = 20000;
  158.         break;
  159.         }
  160.     buffer->bound_size.X = buffer->buf_dim.X;
  161.     buffer->bound_size.Y =
  162.         BOUND_SIZE / (image_size(buffer->bound_size.X, 1, 1, 4));
  163.     (draw->draw)->new_file(r);
  164.     DATA_FILE = FILE_NEW;
  165.     moveTo(1);
  166.     return 0;
  167.     }
  168.  
  169.     switch(n)
  170.     {
  171.     case AC_MOVE:
  172.         global_i[0] = AC_MOVE;
  173.         return 0;
  174.     case AC_RESIZE:
  175.         global_i[0] = AC_RESIZE;
  176.         return 0;
  177.     case AC_FILL_PANEL:
  178.         return 2;
  179.  
  180.     case AC_FILE_MENU:       // go from line menu to the corresponding
  181.     case AC_EDIT_MENU:       // objects
  182.     case AC_EFFECTS_MENU:
  183.     case AC_TEXT_MENU:
  184.     case AC_METHOD_MENU:
  185.     case AC_SCRIPT_MENU:
  186.         return 2;
  187.     case AC_PRINT_MENU:
  188.             if(!buffer->loaded)
  189.         return 0;
  190.             if(!DATA_ZOOM)
  191.                 {
  192.         mouseHideCursor();
  193.                 buffer->b_open();
  194.         buffer->screen_buffer();
  195.                 buffer->b_close();
  196.                 mouseShowCursor();
  197.                 }
  198.         return 2;
  199.  
  200.     case AC_EDIT_CUT:
  201.     case AC_COPY:
  202.     case AC_PASTE:
  203.         DATA_EDIT = n - AC_EDIT_CUT + 1;
  204.         return 1;
  205.     case AC_COPY_FROM:
  206.         DATA_EDIT = n - AC_EDIT_CUT + 1;
  207.         prepare_files();
  208.         (file_sys->edit)->put_string("*.pcx");
  209.         DATA_FILE = FILE_COPY_FROM;
  210.         return 2;
  211.     case AC_COPY_TO:
  212.         DATA_EDIT = n - AC_EDIT_CUT + 1;
  213.         prepare_files();
  214.         (file_sys->edit)->put_string("*.pcx");
  215.         DATA_FILE = FILE_COPY_TO;
  216.         return 2;
  217.     case AC_COPY_TO_BW:
  218.         DATA_EDIT = n - AC_EDIT_CUT + 1;
  219.         prepare_files();
  220.         (file_sys->edit)->put_string("*.pcx");
  221.         DATA_FILE = FILE_COPY_TO_BW;
  222.         return 2;
  223.      case AC_ZOOM:
  224.         if(!buffer->loaded)
  225.         return 1;
  226.         mouseHideCursor();
  227.         WindowManager::hide_window();    // "edit_menu";
  228.         rect r1 = buffer->screen_area;
  229.  
  230.         if(!DATA_ZOOM)             // 1:1 image
  231.         {
  232.                 editList[6][12] = '*';
  233.         buffer->b_open();
  234.         buffer->screen_buffer();
  235.         draw->draw->new_file(r1, 0);     // clear screen, not buf
  236.         int comp
  237.             = max((long)100 * buffer->buf_dim.X
  238.             / buffer->screen_area.width(),
  239.             (long)100 * buffer->buf_dim.Y
  240.             / buffer->screen_area.height());
  241.  
  242.         buffer->screen_position = rect(0, 0,
  243.             buffer->buf_dim.X - 1, buffer->buf_dim.Y - 1);
  244.  
  245.         buffer->buffer_screen(loc(comp, comp), loc(100, 100));
  246.         buffer->b_close();
  247.         DATA_ZOOM = comp;
  248.         }
  249.         else                        // zoomed image
  250.         {
  251.                 editList[6][12] = ' ';
  252.         buffer->screen_position
  253.             = rect(0, 0, buffer->screen_area.width() - 1,
  254.                 buffer->screen_area.height() - 1);
  255.         draw->draw->new_file(r1, 0);     // clear screen, not buf
  256.         buffer->b_open();
  257.         buffer->buffer_screen();
  258.         buffer->b_close();
  259.         DATA_ZOOM = 0;
  260.         }
  261.         moveTo(1);
  262.         mouseShowCursor();
  263.         return 0;
  264.     case AC_TRANS:
  265.         editList[7][12] = DATA_TRANS ? ' ' : '*';
  266.         DATA_TRANS = !DATA_TRANS;
  267.         edit_menu->menu->show();
  268.         return 0;
  269.     case AC_PREVIEW:
  270.         editList[8][12] = DATA_PREVIEW ? ' ' : '*';
  271.         DATA_PREVIEW = !DATA_PREVIEW;
  272.         edit_menu->menu->show();
  273.         return 0;
  274.  
  275.     case AC_FILTER1: case AC_FILTER2: case AC_FILTER3: case AC_FILTER4:
  276.     case AC_FILTER5: case AC_FILTER6: case AC_FILTER7: case AC_FILTER8:
  277.     case AC_FILTER9: case AC_FILTER10: case AC_FILTER11:
  278.     case AC_FILTER12: case AC_FILTER13: case AC_FILTER14:
  279.         WindowManager::hide_window();    // "filters"
  280.             WindowManager::hide_window();    // "effects_menu"
  281.         DATA_FILTER = n - AC_FILTER1 + 1;
  282.         moveTo(get(menu));
  283.         return 0;
  284.  
  285.     case AC_DITHER1: case AC_DITHER2: case AC_DITHER3: case AC_DITHER4:
  286.     case AC_DITHER5: case AC_DITHER6: case AC_DITHER7: case AC_DITHER8:
  287.     case AC_DITHER9: case AC_DITHER10: case AC_DITHER11:
  288.     case AC_DITHER12: case AC_DITHER13: case AC_DITHER14:
  289.         WindowManager::hide_window();    // "dithers"
  290.         WindowManager::hide_window();    // "effects_menu";
  291.         DATA_DITHER = n - AC_DITHER1;
  292.         moveTo(get(menu));
  293.         return 0;
  294.  
  295.     case AC_NO_GRAD: case AC_HORIZ_GRAD: case AC_VERT_GRAD:
  296.         WindowManager::hide_window();    //grads->hide();
  297.         WindowManager::hide_window();    //effects_menu->hide();
  298.         DATA_GRAD = n - AC_NO_GRAD;
  299.         moveTo(get(menu));
  300.         return 0;
  301.  
  302.     case AC_NO_ERROR_PROP: case AC_ERROR_PROP_ON:
  303.         WindowManager::hide_window();    //error_prop->hide();
  304.         WindowManager::hide_window();    //effects_menu->hide();
  305.         DATA_ERROR_PROP = n - AC_NO_ERROR_PROP;
  306.         moveTo(get(menu));
  307.         return 0;
  308.  
  309.     case AC_TOOLS_1: case AC_TOOLS:        // go here from "methods menu"
  310.     case AC_COLORS:
  311.     case AC_BAKS: case AC_FILL_PROMPT:
  312.     case AC_DRAW:
  313.         return 2;
  314.  
  315.     case AC_FILTERS: case AC_DITHERS: case AC_GRADS: case AC_ERROR_PROP:
  316.         return 2;
  317.  
  318.     case AC_TOOL_UNDO:
  319.         DATA_TOOLS = TOOL_UNDO;
  320.         return 0;
  321.     case AC_FILTER:
  322.         DATA_TOOLS = TOOL_FILTER;
  323.         return 0;
  324.     case AC_DITHER:
  325.         DATA_TOOLS = TOOL_DITHER;
  326.         return 0;
  327.     case AC_TEXT:
  328.         DATA_TOOLS = TOOL_TEXT;
  329.         return 0;
  330.     case AC_SCROLL:
  331.         DATA_TOOLS = TOOL_SCROLL;
  332.         return 0;
  333.  
  334.     case AC_LOCAL_UNDO:
  335.         DATA_TOOLS = TOOL_LOCAL_UNDO;
  336.         return 0;
  337.     case AC_HORIZ:          // set text directions
  338.         DATA_DIR = 0;
  339.         return 1;
  340.     case AC_VERT:
  341.         DATA_DIR = 1;
  342.         return 1;
  343.     case AC_LINE_WIDTH:        // special case, continue after it.
  344.         return 2;          // Here represents next menu with line width
  345.     case AC_MICROSCOPE_2:
  346.         set_call(micro, draw);
  347.         return 1;
  348.     case AC_MICROSCOPE:                    // go to microscope
  349.         DATA_TOOLS = TOOL_MICRO;
  350.         global_i[6] = DATA_ATTR;
  351.         global_i[7] = DATA_BAK;
  352.         r_draw_size = draw->draw->user_screen();
  353.         return 2;
  354.  
  355.     case AC_SCISSORS:
  356.         DATA_TOOLS = TOOL_SCISSORS;
  357.         return 0;
  358.     case AC_ERASER:
  359.         DATA_TOOLS = TOOL_ERASER;
  360.         return 0;
  361.     case AC_COLOR_ERASER:
  362.         DATA_TOOLS = TOOL_COLOR_ERASER;
  363.         return 0;
  364.     case AC_FILL:
  365.         DATA_TOOLS = TOOL_FILL;
  366.         return 0;
  367.     case AC_RECTANGLE:
  368.         DATA_TOOLS = TOOL_RECTANGLE;
  369.         return 0;
  370.     case AC_CIRCLE:
  371.         DATA_TOOLS = TOOL_CIRCLE;
  372.         return 0;
  373.     case AC_LINE:
  374.         DATA_TOOLS = TOOL_LINE;
  375.         return 0;
  376.     case AC_PEN:
  377.         DATA_TOOLS = TOOL_PEN;
  378.         return 0;
  379.  
  380.     case AC_PRINT:
  381. // Remark the following code if you do not use Print Manager
  382.         if(!buffer->loaded)
  383.         return 1;
  384.         buffer->b_open();
  385.         print->set_type(form->p_t);
  386.         print->set_density(form->d);
  387.         print->set_pass(form->pas);
  388.         print->set_comp(form->m_x, form->m_y,
  389.         form->d_x, form->d_y);
  390.         print->set_left(form->l);
  391.         print->set_paper(form->pap);
  392.             for(int cop = 0; cop < form->cop && !kbhit(); cop++)
  393.                 print->draw_pages(buffer, "_work1.buf");
  394.         buffer->b_close();
  395.         return 1;
  396.     case AC_TEXT_SIZE:                      // go here from "size_menu"
  397.     case AC_TEXT_DIR:
  398.         return 2;
  399.     case AC_TEXT_FONT:
  400.         prepare_files();
  401.         (file_sys->edit)->put_string("*.sfp");
  402.         DATA_FILE = FILE_FONT;
  403.         return 2;
  404.     case AC_NEW:
  405.         prepare_files();
  406.         return 2;
  407.     case AC_OPEN:
  408.         if(DATA_ZOOM)
  409.         return 1;
  410.         prepare_files();
  411.         (file_sys->edit)->put_string("*.pcx");
  412.         DATA_FILE = FILE_OPEN;
  413.         return 2;
  414.     case AC_SAVE:
  415.         prepare_files();
  416.         (file_sys->edit)->put_string("*.pcx");
  417.         DATA_FILE = FILE_SAVE;
  418.         return 2;
  419.     case AC_SAVE_AS_BW:
  420.         prepare_files();
  421.         (file_sys->edit)->put_string("*.pcx");
  422.         DATA_FILE = FILE_SAVE_AS_BW;
  423.         return 2;
  424.     case AC_ABOUT:
  425.         about();
  426.             return 1;
  427.  
  428.     case AC_SCRIPT_PLAY:
  429.         if(DATA_ZOOM)
  430.         return 1;
  431.         DATA_FILE = SCRIPT_PLAY;
  432.         prepare_files();
  433.         (file_sys->edit)->put_string("*.sc");  // set mask for file system
  434.         return 2;
  435.     case AC_SCRIPT_RECORD:                          // recording of script
  436.         if(DATA_ZOOM)
  437.         return 1;
  438.         prepare_files();
  439.         DATA_FILE = SCRIPT_RECORD;
  440.         (file_sys->edit)->put_string("*.sc");
  441.         return 2;
  442.     case AC_SCRIPT_END:                        // end of script recording.
  443.         DATA_FILE = SCRIPT_END;
  444.         file_refresh();
  445.         return 1;
  446.     case AC_MACROS_KEEP:
  447.         DATA_FILE = MACROS_KEEP;
  448.  
  449.         if(scriptMode == PLAY)
  450.         {
  451.         scriptMode = GO;
  452.         return 1;
  453.         }
  454.  
  455.         file_refresh();
  456.         prepare_files();
  457.         (file_sys->edit)->put_string("*.sc");
  458.  
  459.         return 2;
  460.  
  461.     case AC_EDITOR:
  462.         DATA_FILE = TEXT_EDIT;
  463.         file_refresh();
  464.         prepare_files();
  465.         (file_sys->edit)->put_string("*.sc");
  466.         return 2;
  467.  
  468.     case AC_ASK_EXIT:
  469.         askSave();
  470.         return ask_exit();
  471.  
  472.         case AC_TEXT_EDIT:
  473. //            editor->hide();
  474.             moveTo(1);
  475.             return 0;
  476.  
  477.     case AC_FILE:
  478.             if(DATA_FILE != TEXT_EDIT)
  479.                 WindowManager::hide_window();    // file_sys->hide();
  480.         if(DATA_FILE != FILE_COPY_FROM && DATA_FILE != FILE_COPY_TO
  481.            && DATA_FILE != FILE_COPY_TO_BW
  482.            && DATA_FILE != TEXT_EDIT)
  483.         WindowManager::hide_window();    // file_menu->hide();
  484.                          // script_menu->hide();
  485.                          // text_menu->hide();
  486.         if(DATA_FILE == FILE_OPEN)
  487.         askSave();
  488.  
  489. //        set_call(file_sys, draw);
  490.         switch(DATA_FILE)
  491.         {
  492.         case TEXT_EDIT:
  493.             editor->set_call(1);
  494.             editor->write->set_swap(global[global_i[1]]);
  495. //            editor->write->load_file();        // to be corrected
  496.             return 2;
  497.  
  498.         case FILE_OPEN:                         // load
  499.             unlink(buffer->file_name);
  500.             buffer->buf_dim.X = 750;
  501.             buffer->buf_dim.Y = 550;
  502.             buffer->bound_size.X = buffer->buf_dim.X;
  503.             buffer->bound_size.Y =
  504.                 BOUND_SIZE / (image_size(buffer->bound_size.X, 1, 1, 4));
  505.  
  506.             (draw->draw)->new_file(r);
  507.             (draw->draw)->load();
  508.             moveTo(1);
  509.             return 0;
  510.         case FILE_FONT:
  511.             delete fontName;
  512.             fontName = strdup(global[global_i[1]]);
  513.             moveTo(1);
  514.             return 0;
  515.  
  516.         case FILE_SAVE:                         // save
  517.             (draw->draw)->save();
  518.             moveTo(1);
  519.             return 0;
  520.         case FILE_SAVE_AS_BW:                   // save BW
  521.             (draw->draw)->save();
  522.             pcx_col_to_bw(global[global_i[1]], "tmp____u.pcy");
  523.             unlink(global[global_i[1]]);
  524.             rename("tmp____u.pcy", global[global_i[1]]);
  525.             moveTo(1);
  526.             return 0;
  527.  
  528.         case FILE_COPY_FROM:                         // COPY FROM
  529.             if(!buffer->loaded)
  530.             return 1;
  531.  
  532.             rect reserv1 = r;
  533.             rect reserv = r;
  534.             r.origin.X += 8 - r.origin.X % 8;
  535.  
  536.             if(!DATA_ZOOM)
  537.             {
  538.             mouseHideCursor();
  539.             buffer->b_open();
  540.             buffer->screen_buffer();
  541.             buffer->b_close();
  542.             mouseShowCursor();
  543.             }
  544.             pcxheader p_h;
  545.             get_pcx_header(global[global_i[1]], &p_h);
  546.             int xsize = getmaxx() + 2;
  547.             int ysize = getmaxy() + 2;
  548.             if((p_h.x2 - p_h.x1 + 1 + 7) / 8 * 8 + 1 > xsize)
  549.             xsize = (p_h.x2 - p_h.x1 + 1 + 7) / 8 * 8 + 1;
  550.             if(p_h.y2 - p_h.y1 + 8 > ysize)
  551.             ysize = p_h.y2 - p_h.y1 + 8;
  552.  
  553.             int z = (DATA_ZOOM > 0)
  554.             ? DATA_ZOOM : 100;
  555.  
  556.             GrafBuffer* buf1 = new GrafBuffer(loc(xsize, ysize),
  557.             "_work1.buf", r);
  558.             int comp = (DATA_ZOOM > 0) ?
  559.             max((long)100 * buf1->buf_dim.X
  560.             / buf1->screen_area.width(),
  561.             (long)100 * buf1->buf_dim.Y
  562.             / buf1->screen_area.height())
  563.             : 100;
  564.  
  565.             buf1->b_open();
  566.             buf1->clear();
  567.             pcx_file_buffer(buf1, loc(0, 0), global[global_i[1]]);
  568.  
  569. /*            if(DATA_ZOOM)
  570.             r = rect(r.origin,
  571.                 loc(r.origin.X
  572.                 + (long)buf1->buf_dim.X * 100 / comp,
  573.                 r.origin.Y
  574.                 + (long)buf1->buf_dim.Y * 100 / comp));
  575.             buf1->screen_area = r;
  576.                   buf1->screen_position = rect(0, 0,
  577.             buf1->buf_dim.X - 1, buf1->buf_dim.Y - 1);
  578. */
  579.             buf1->buffer_screen(loc(comp, comp), loc(100, 100));
  580.  
  581.             mouseShowCursor();
  582.             e = getevent(KEYEVENT | MOUSEEVENT,
  583.              MCleftDn | MCcenterDn | MCrightDn);
  584.             mspos = draw->draw->verify_rect(r);
  585.             mouseHideCursor();
  586.             work = get_dim(FIG_RECTANGLE, RESIZE, r,
  587.                 rect(mspos, mspos + minsize));
  588.             r = reserv;
  589.  
  590.             if(!(work.origin.X == work.corner.X ||
  591.                work.origin.Y == work.corner.Y))
  592.             buf1->pcx_buffer_file(
  593.                  rect((buf1->screen_position.origin.X +
  594.                      (long)(work.origin.X
  595.                      - buf1->screen_area.origin.X)
  596.                       * comp / 100 + 7) / 8 * 8,
  597.                  buf1->screen_position.origin.Y +
  598.                      (long)(work.origin.Y
  599.                      - buf1->screen_area.origin.Y)
  600.                       * comp / 100,
  601.                  (buf1->screen_position.origin.X +
  602.                      (long)(work.corner.X
  603.                      - buf1->screen_area.origin.X)
  604.                       * comp / 100 + 7) / 8 * 8 - 1,
  605.                  buf1->screen_position.origin.Y +
  606.                      (long)(work.corner.Y
  607.                      - buf1->screen_area.origin.Y)
  608.                       * comp / 100),
  609.                  "copy.pcy");
  610.             buf1->b_close();
  611.             delete buf1;
  612.  
  613.             buffer->b_open();
  614.             buffer->buffer_screen(loc(z, z), loc(100, 100));
  615.             buffer->b_close();
  616.             setfillpattern(pattern[DATA_FILL],
  617.             DATA_BAK);
  618.             r = reserv1;
  619.             moveTo(get(draw));
  620.             mouseShowCursor();
  621.             return 0;
  622.  
  623.         case FILE_COPY_TO:                   // COPY TO
  624.             if(!buffer->loaded)
  625.             return 1;
  626.  
  627.             mouseShowCursor();
  628.             e = getevent(KEYEVENT | MOUSEEVENT,
  629.              MCleftDn | MCcenterDn | MCrightDn);
  630.             mouseHideCursor();
  631.             draw->draw->cut_copy(global[global_i[1]]);
  632.             moveTo(1);
  633.             mouseShowCursor();
  634.             return 0;
  635.         case FILE_COPY_TO_BW:
  636.             if(!buffer->loaded)
  637.             return 1;
  638.  
  639.             mouseShowCursor();
  640.             e = getevent(KEYEVENT | MOUSEEVENT,
  641.              MCleftDn | MCcenterDn | MCrightDn);
  642.             mouseHideCursor();
  643.             draw->draw->cut_copy(global[global_i[1]]);
  644.             pcx_col_to_bw(global[global_i[1]], "tmp____u.pcy");
  645.             unlink(global[global_i[1]]);
  646.             rename("tmp____u.pcy", global[global_i[1]]);
  647.             moveTo(1);
  648.             mouseShowCursor();
  649.             return 0;
  650.         case SCRIPT_PLAY:                          // PLAY mode
  651.             mac_status mac;              // remember old file executed
  652.             mac.file = scriptFileName
  653.             ? strdup(scriptFileName) : NULL;
  654.             mac.ptr = scriptPtr;
  655.             mac.mode = scriptMode;
  656.  
  657.             fpos_t reserv_pos;
  658.             fgetpos(scriptPtr, &reserv_pos);
  659.             mac.pos = reserv_pos;
  660.  
  661.             macros_push(mac);        // keep it in the stack
  662.  
  663.             delete scriptFileName;
  664.             scriptFileName = global[global_i[1]]      // if file name
  665.             ? strdup(global[global_i[1]]) : NULL; // is set
  666.  
  667.             fclose(scriptPtr);
  668.             fclose(macrosPtr);
  669.  
  670.             scriptPtr = fopen(scriptFileName, "r");
  671.             macrosPtr = fopen(macrosFileName, "r");
  672.  
  673.             scriptMode = PLAY;
  674.                     moveTo(1);
  675.             return 0;
  676.         case SCRIPT_RECORD:                              // RECORD
  677.             delete scriptFileName;
  678.             scriptFileName = global[global_i[1]]
  679.             ? strdup(global[global_i[1]]) : NULL;
  680.             scriptPtr = fopen(scriptFileName, "w+");
  681.             scriptMode = RECORD;
  682.                     moveTo(1);
  683.             return 0;
  684.         case SCRIPT_END:
  685.             scriptMode = GO;
  686.             fclose(scriptPtr);
  687.                     moveTo(1);
  688.             return 0;
  689.  
  690.         case MACROS_KEEP:                   // KEEP SCRIPT AS MACROS
  691.             int hot_result = ask_hot_key();  // (and end record before)
  692.  
  693.             if(!hot_result)             // ESC or mouse button pressed
  694.             return 0;
  695.  
  696.             scriptFileName = global[global_i[1]]
  697.             ? strdup(global[global_i[1]]) : NULL;
  698.  
  699.             fclose(scriptPtr);
  700.             fclose(macrosPtr);
  701.  
  702.             scriptPtr = fopen(scriptFileName, "r");
  703.             macrosPtr = fopen(macrosFileName, "r");
  704.  
  705.             FILE* tempPtr = fopen("temp.sc", "w");  // temp file for
  706.                                 // duplication
  707.             char command[22];
  708.             get_command(command);   // transfer e.key, set by ask_hot_key to command
  709.             add_macros(command, tempPtr);  // add the macros
  710.  
  711.             fclose(tempPtr);
  712.             fclose(macrosPtr);
  713.  
  714.             unlink(macrosFileName);                  // new macros file
  715.             rename("temp.sc", macrosFileName);
  716.             macrosPtr = fopen(macrosFileName, "r");
  717.  
  718.             init_macros();     // rebuild table of macroses
  719.  
  720.             delete scriptFileName;
  721.             scriptFileName = NULL;
  722.                     moveTo(1);
  723.             return 0;
  724.         }
  725.  
  726.     default:
  727.         return 0;
  728.     }
  729.     }
  730. //////////////////////
  731.  
  732.